package com.yk.neon.lib.util.base.string;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.ThreadLocalRandom;

public class StringUtil {

	/**
	 * 用于随机选的数字
	 */
	public static final String BASE_NUMBER = "0123456789";

	/**
	 * 默认的空值
	 */
	public static final String EMPTY = "";

	/**
	 * 检查字符串是否为空
	 * 
	 * @param str
	 *            字符串
	 * @return
	 */
	public static boolean isEmpty(String str) {
		if (str == null) {
			return true;
		} else if (str.length() == 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 检查字符串是否为空
	 * 
	 * @param str
	 *            字符串
	 * @return
	 */
	public static boolean isNotEmpty(String str) {
		return !isEmpty(str);
	}

	/**
	 * 截取并保留标志位之前的字符串
	 * 
	 * @param str
	 *            字符串
	 * @param expr
	 *            分隔符
	 * @return
	 */
	public static String substringBefore(String str, String expr) {
		if (isEmpty(str) || expr == null) {
			return str;
		}
		if (expr.length() == 0) {
			return EMPTY;
		}
		int pos = str.indexOf(expr);
		if (pos == -1) {
			return str;
		}
		return str.substring(0, pos);
	}

	/**
	 * 截取并保留标志位之后的字符串
	 * 
	 * @param str
	 *            字符串
	 * @param expr
	 *            分隔符
	 * @return
	 */
	public static String substringAfter(String str, String expr) {
		if (isEmpty(str)) {
			return str;
		}
		if (expr == null) {
			return EMPTY;
		}
		int pos = str.indexOf(expr);
		if (pos == -1) {
			return EMPTY;
		}
		return str.substring(pos + expr.length());
	}

	/**
	 * 截取并保留最后一个标志位之前的字符串
	 * 
	 * @param str
	 *            字符串
	 * @param expr
	 *            分隔符
	 * @return
	 */
	public static String substringBeforeLast(String str, String expr) {
		if (isEmpty(str) || isEmpty(expr)) {
			return str;
		}
		int pos = str.lastIndexOf(expr);
		if (pos == -1) {
			return str;
		}
		return str.substring(0, pos);
	}

	/**
	 * 截取并保留最后一个标志位之后的字符串
	 * 
	 * @param str
	 * @param expr
	 *            分隔符
	 * @return
	 */
	public static String substringAfterLast(String str, String expr) {
		if (isEmpty(str)) {
			return str;
		}
		if (isEmpty(expr)) {
			return EMPTY;
		}
		int pos = str.lastIndexOf(expr);
		if (pos == -1 || pos == (str.length() - expr.length())) {
			return EMPTY;
		}
		return str.substring(pos + expr.length());
	}

	/**
	 * 把字符串按分隔符转换为数组
	 * 
	 * @param string
	 *            字符串
	 * @param expr
	 *            分隔符
	 * @return
	 */
	public static String[] stringToArray(String string, String expr) {
		return string.split(expr);
	}

	/**
	 * 去除字符串中的空格
	 * 
	 * @param str
	 * @return
	 */
	public static String noSpace(String str) {
		str = str.trim();
		str = str.replace(" ", "_");
		return str;
	}

	/**
	 * 获取中文字符个数
	 * 
	 * @param strZh
	 *            中文字符串
	 * @return 中文个数
	 */
	public static Integer strZhCount(String strZh) {
		Integer count = 0;
		String regEx = "[^\u4e00-\u9fa5]+";
		String[] term = strZh.split(regEx);
		for (int i = 0; i < term.length; i++) {
			count += term[i].length();
		}
		return count;
	}

	/**
	 * 返回长度为【strLength】的随机数，在前面补0
	 */
	public static String getRandomString(int strLength) {

		Random rm = new Random();

		// 获得随机数
		double pross = (1 + rm.nextDouble()) * Math.pow(10, strLength);

		// 将获得的获得随机数转化为字符串
		String fixLenthString = String.valueOf(pross);

		// 返回固定的长度的随机数
		return fixLenthString.substring(2, strLength + 2);
	}

	/**
	 * 返回长度为【strLength】的随机数
	 */
	public static String getRandom() {
		Random r = new Random();
		long num = Math.abs(r.nextLong() % 10000000000L);
		String s = String.valueOf(num);
		for (int i = 0; i < 10 - s.length(); i++) {
			s = "0" + s;
		}
		return s;
	}

	/**
	 * 获取随机字符串 Nonce Str
	 *
	 * @return String 随机字符串
	 */
	public static String createNonceStr(Integer length) {
		if (length <= 0 || length > 32) {
			length = 32;
		}
		return UUID.randomUUID().toString().replaceAll("-", "").substring(0, length);
	}

	/**
	 * 获取现在时间单号
	 * @param headStr
	 * 				单号前缀
	 * @return yyMMddHHmmssSSSSSS类型
	 */
	public static String getOrderNo(String headStr) {
		SimpleDateFormat formatter = new SimpleDateFormat("yyMMddHHmmssSSS");
		StringBuffer buffer = new StringBuffer();
		buffer.append(headStr).append(formatter.format(new Date())).append(randomNumbers(7));
		return buffer.toString();
	}
	/**
	 * 获得一个只包含数字的字符串
	 *
	 * @param length 字符串的长度
	 * @return 随机字符串
	 */
	public static String randomNumbers(int length) {
		return randomString(BASE_NUMBER, length);
	}

	/**
	 * 获得一个随机的字符串
	 *
	 * @param baseString 随机字符选取的样本
	 * @param length     字符串的长度
	 * @return 随机字符串
	 */
	public static String randomString(String baseString, int length) {
		final StringBuilder sb = new StringBuilder(length);

		if (length < 1) {
			length = 1;
		}
		int baseLength = baseString.length();
		for (int i = 0; i < length; i++) {
			int number = randomInt(baseLength);
			sb.append(baseString.charAt(number));
		}
		return sb.toString();
	}
	/**
	 * 获得指定范围内的随机数 [0,limit)
	 *
	 * @param limit 限制随机数的范围，不包括这个数
	 * @return 随机数
	 */
	public static int randomInt(int limit) {
		return getThreadLocalRandom().nextInt(limit);
	}
	/**
	 * 获取随机数生成器对象<br>
	 * ThreadLocalRandom是JDK 7之后提供并发产生随机数，能够解决多个线程发生的竞争争夺。
	 *
	 * <p>
	 * 注意：此方法返回的{@link ThreadLocalRandom}不可以在多线程环境下共享对象，否则有重复随机数问题。
	 * 见：https://www.jianshu.com/p/89dfe990295c
	 * </p>
	 *
	 * @return {@link ThreadLocalRandom}
	 * @since 3.1.2
	 */
	public static ThreadLocalRandom getThreadLocalRandom() {
		return ThreadLocalRandom.current();
	}


	/**
	 * 获取现在时间单号火车
	 * @param headStr
	 * 				单号前缀
	 */
	  public static String[] chars = new String[] {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};

	    public static String getShortUuid(String headStr) {
	        StringBuffer stringBuffer = new StringBuffer();
	        stringBuffer.append(headStr);
	        String uuid = UUID.randomUUID().toString().replace("-", "");
	        for (int i = 0; i < 18; i++) {
	            String str = uuid.substring(i,i+1);
	            int strInteger = Integer.parseInt(str, 16);
	            stringBuffer.append(chars[strInteger % 0xA]);
	        }
	        return stringBuffer.toString();
	    }

		
		
	public static String Obj2Str(Object o){
		if(o==null||o.equals("null")||o.equals("")){
			return null;
		}else{
			return o.toString();
		}
	}

	/**
	 * 判断是否UTF-8 URL编码
	 * @param text
	 * @return
	 */
	public static boolean isUtf8Url(String text) {
		text = text.toLowerCase();
		int p = text.indexOf("%");
		if (p != -1 && text.length() - p > 9) {
			text = text.substring(p, p + 9);
		}
		return Utf8codeCheck(text);
	}

	/**
	 * 判断URL编码是否有效
	 * @param text
	 * @return
	 */
	private static  boolean Utf8codeCheck(String text){
		String sign = "";
		if (text.startsWith("%e")) {
			for (int i = 0, p = 0; p != -1; i++) {
				p = text.indexOf("%", p);
				if (p != -1) {
					p++;
				}
				sign += p;
			}
		}
		return sign.equals("147-1");
	}


	/**
	 * 隐私数据掩码
	 * @param text 隐私数据
	 * @return
	 */
	public static String dataMask(String text) {
		if (isEmpty(text)) {
			return text;
		} else if (text.length() < 6) {
			return text;
		}
		StringBuilder maskText = new StringBuilder();
		try {
			// 邮箱处理
			if (text.contains("@")) {
				String emialName = text.split("@")[0];
				int maskLength = emialName.length() / 3 + 1;
				int beginIndex = (emialName.length() - maskLength) / 2;
				int endIndex = beginIndex + maskLength;
				maskText.append(emialName.substring(0, beginIndex));
				for (int i = 0; i < maskLength; i++) {
					maskText.append("*");
				}
				maskText.append(text.substring(endIndex));
			} else {
				// 非邮箱处理
				switch (text.length()) {
					// 手机号,11位,保留前三位后四位
					case 11:
						maskText.append(text.substring(0, 3)).append("****").append(text.substring(text.length() - 4));
						break;
					// 护照号和港澳通行证,9位,保留前四位后三位
					case 9:
						maskText.append(text.substring(0, 4)).append("**").append(text.substring(text.length() - 3));
						break;
					// 一代身份证号,15位,保留前四位后三位
					case 15:
						maskText.append(text.substring(0, 4)).append("********").append(text.substring(text.length() - 3));
						break;
					// 二代身份证号,18位,保留前四位后三位
					case 18:
						maskText.append(text.substring(0, 4)).append("***********")
								.append(text.substring(text.length() - 3));
						break;
					// 默认处理,保留前两位后两位
					default:
						maskText.append(text.substring(0, 2)).append("****").append(text.substring(text.length() - 2));
						break;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return maskText.toString();
	}


}
